Stream模板+Lambda常用+@注释+常用方法模板集合

2024/11/22

后端

Stream模板

中间方法

中间方法的特点惰性求值：中间操作不会立即执行，而是返回一个新的流。实际的计算会在遇到终结方法时进行。可以链式调用：多个中间操作可以链接在一起，形成一个操作链。返回类型：所有的中间操作返回的都是一个 Stream 对象。

Stream中间代码

功能：过滤流中的元素，仅保留满足给定条件的元素。
// 示例：
Stream.of(1, 2, 3, 4, 5)
      .filter(n -> n % 2 == 0) // 只保留偶数
      .forEach(System.out::println);//打印功能：将流中的元素映射为其他形式（通常是不同类型）。
// 示例：
Stream.of("a", "b", "c")
     .map(String::toUpperCase) // 将每个字符串转换为大写功能：将流中的每个元素映射为一个流，并将所有流连接成一个流。示例：Stream<List<String>> listStream = Stream.of(Arrays.asList("a", "b"), Arrays.asList("c", "d"));
listStream
    .flatMap(List::stream) // 将嵌套列表展平为一个流
    .forEach(System.out::println);功能：去除流中的重复元素。示例：Stream.of(1, 2, 2, 3, 4, 4)
     .distinct()
     .forEach(System.out::println); // 输出 1, 2, 3, 4功能：对流中的元素进行排序。示例：Stream.of(5, 3, 1, 4, 2)
     .sorted() // 默认升序排序
     .forEach(System.out::println);功能：截取流中的前 maxSize 个元素。示例：Stream.of(1, 2, 3, 4, 5)
     .limit(3) // 只保留前 3 个元素
     .forEach(System.out::println);功能：跳过流中的前 n 个元素。示例：Stream.of(1, 2, 3, 4, 5)
     .skip(2) // 跳过前 2 个元素
     .forEach(System.out::println); // 输出 3, 4, 5下面是一个示例，展示了多种中间方法的使用：import java.util.Arrays;
import java.util.List;

中间方法：

中间方法的特点
惰性求值：中间操作不会立即执行，而是返回一个新的流。实际的计算会在遇到终结方法时进行。
可以链式调用：多个中间操作可以链接在一起，形成一个操作链。
返回类型：所有的中间操作返回的都是一个 Stream 对象。

stream中间操作

功能：过滤流中的元素，仅保留满足给定条件的元素。

示例：

Stream.of(1, 2, 3, 4, 5)
.filter(n -> n % 2 == 0) // 只保留偶数
.forEach(System.out::println);//打印

功能：将流中的元素映射为其他形式（通常是不同类型）。

示例：

Stream.of("a", "b", "c")
     .map(String::toUpperCase) // 将每个字符串转换为大写

功能：将流中的每个元素映射为一个流，并将所有流连接成一个流。

示例：

Stream<List<String>> listStream = Stream.of(Arrays.asList("a", "b"), Arrays.asList("c", "d"));
listStream
    .flatMap(List::stream) // 将嵌套列表展平为一个流
    .forEach(System.out::println);

功能：去除流中的重复元素。
示例：

Stream.of(1, 2, 2, 3, 4, 4)
     .distinct()
     .forEach(System.out::println); // 输出 1, 2, 3, 4

功能：对流中的元素进行排序。
示例：

Stream.of(5, 3, 1, 4, 2)
     .sorted() // 默认升序排序
     .forEach(System.out::println);

功能：截取流中的前 maxSize 个元素。
示例：

Stream.of(1, 2, 3, 4, 5)
     .limit(3) // 只保留前 3 个元素
     .forEach(System.out::println);

功能：跳过流中的前 n 个元素。
示例：

Stream.of(1, 2, 3, 4, 5)
     .skip(2) // 跳过前 2 个元素
     .forEach(System.out::println); // 输出 3, 4, 5

下面是一个示例，展示了多种中间方法的使用：

import java.util.Arrays;
import java.util.List;
public class StreamIntermediateOperations {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

    // 使用中间方法
    names.stream()
        .filter(name -&gt; name.startsWith(&quot;A&quot;)) // 过滤以 'A' 开头的名字
        .map(String::toUpperCase) // 将名字转换为大写
        .sorted() // 排序
        .forEach(System.out::println); // 输出结果
}

}

终结方法

在 Java Stream API 中，终结方法（Terminal Operations）是指那些会触发流的计算并最终产生结果的方法。与中间操作不同，终结方法会结束流的操作链，并返回一个具体的结果或副作用。以下是对终结方法的详细介绍：

1. 终结方法的特点

触发计算：终结方法会对流中的数据进行处理并生成结果，通常会遍历流中的所有元素。

返回类型：终结方法可以返回不同类型的结果，包括：

基本类型（如 int、double）

对象（如 List、Set、Map）

特殊值（如 Optional、Void）

终结方法

功能：对流中的每个元素执行指定的操作。

示例：

Stream.of("a", "b", "c").forEach(System.out::println);

功能：将流中的元素收集到集合或其他形式。

示例：

List<String> list = Stream.of("a", "b", "c").collect(Collectors.toList());

功能：对流中的元素进行归约，返回一个单一的结果。

示例：

int sum = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);

功能：返回流中元素的数量。

示例：

long count = Stream.of("a", "b", "c").count();

功能：检查流中是否有任何元素满足给定的条件。

示例：

boolean hasA = Stream.of("a", "b", "c").anyMatch(s -> s.equals("a"));

功能：检查流中所有元素是否满足给定的条件。

示例：

boolean allMatch = Stream.of(1, 2, 3).allMatch(n -> n < 5);

功能：返回流中的第一个元素（如果存在）。

示例：

Optional<String> first = Stream.of("a", "b", "c").findFirst();

下面是一个示例，展示了多种终结方法的使用：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


public class StreamTerminalOperations {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
    // forEach
    names.stream().forEach(System.out::println);

    // collect
    List&lt;String&gt; filteredNames = names.stream()
        .filter(name -&gt; name.startsWith(&quot;A&quot;))
        .collect(Collectors.toList());
    System.out.println(filteredNames);

    // reduce
    String concatenated = names.stream()
        .reduce(&quot;&quot;, (a, b) -&gt; a + b);
    System.out.println(concatenated);
    
    // count
    long count = names.stream().count();
    System.out.println(&quot;Count: &quot; + count);
    
    // findFirst
    String firstName = names.stream().findFirst().orElse(&quot;No Name&quot;);
    System.out.println(&quot;First Name: &quot; + firstName);
}

}

stream流超强引用

package com.itheima.pojo.test;

import java.util.*;
import java.util.stream.Collectors;

/**
 * Arrays.asList 是 Java 中 java.util.Arrays 类的一个静态方法，
 * 用于将指定的数组或可变数量的参数转换为一个固定大小的 List。
 * 这个 List 是 ArrayList 的一个内部实现类，
 * 但它不是 java.util.ArrayList，
 * 而是一个不可变的列表
 */
public class Test2 {
    public static void main(String[] args) {
        // List<String> list：将上述列表赋值给 list 变量
        List<String> list = Arrays.asList("apple", "banana", "orange");
        // 定义一个映射，键为整数，值为字符串列表 = 创建一个新的空哈希映射
        // 键的类型是 Integer，值的类型是 List<String> 表示具有相同长度的字符串列表
        // 用HashMap  允许 null 值：键和值都可以为 null，但键只能有一个 null。
        Map<Integer, List<String>> groups = new HashMap<>();
        for (String s : list) {
            int length = s.length();
            // 检查 groups 映射中是否已经存在键为 length 的条目
            if (!groups.containsKey(length)) {
                // 将新创建的列表作为值，以 length 为键添加到 groups 映射中
                // 创建一个新的 ArrayList，并将当前字符串 s 添加到其中
                groups.put(length, new ArrayList<>(Arrays.asList(s)));
            } else {
                // 从 groups 映射中获取键为 length 的列表
                List<String> group = groups.get(length);
                group.add(s);
            }
            System.out.println(groups);
        }

        // 使用 Stream API 进行分组
        // 使用 Collectors.groupingBy 方法按字符串长度进行分组
        // 将分组结果收集到一个新的映射 group2 中。
        Map<Integer, List<String>> group2 = list.stream().collect(Collectors.groupingBy(String::length));
        System.out.println(group2);
    }
}

Lambda+Stream实用方法

// 创建一个包含字符串的列表
List<String> List = Arrays.asList("apple","banana", "orange");
1.for循环输出
for (String s : list){
System.out.println(s);}

2.表达式输出   
list.forEach(s ->
System.out.println(s);});

3.表达式最简洁输出
List.forEach(System.out::println);

// 创建一个包含字符串的列表
List<String> list = Arrays.asList("apple","banana", "orange");

1.使用重写Collections 排序
Collections.sort(list,new Comparator<String>（） {
@override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});

2.使用lambda表达式排序
Collections.sort(list,(o1,o2) ->{
    return o1.compareTo(o2)
});

3.使用最简洁的表达式
Collections.sort(list,(o1,o2) ->{o1.compareTo(o2)});

// 创建一个包含字符串的列表
List<String> list = Arrays.asList("apple","banana", "orange");

1.普通方式过滤
List<String> list2 = new ArrayList<>();
List<String s : list2){
if(s.startsWith("a")){
     list2.add(s);
} }

2.使用 Stream API 进行过滤和收集,过滤以 'a' 开头的字符串,收集结果到一个新的 List 中
List<String>list3 = list.stream().filter(s - > s.startsWith("a")).collect(Collectrs.toList());

// 创建一个包含字符串的列表
List<String> list = Arrays.asList("apple","banana", "orange");

1.普通方式获取长度
List<Integer> List2 = new ArrayList<>();
for （String s:list){
    
list2.add(s.length());}

2.Lambda表达式+stream流获取长度
(map)这个函数对我们管道中的每个元素做了处理，在此处为把string转换为Integer类型 主要进行转换作用
List<Integer> list3 = list.stream().map(s -> s.length()).collect(Collectors.toList());

//新建一个List集合
List<Integer> list = Arrays.asList（1,2, 3, 4, 5);
1.普通方式相加操作
int sum =0;
for (Integer v : list) {
SUm +=V  }
System.out.println(sum);

2.Lambda+stream
(表达式含义)：【0】操作的起始值，【a = a+b】 循环下去
int sum2 = list.stream().reduce( identity: 0, (a, b) -> a + b);
System.out.println(sum2)

//新建一个集合
List<String> list = Arrays.asList("apple", "banana", "orange");

Map<Integer,List<String>> groups = new HashMap<>();

1.普通方式分组
for （String s:list){
int length = s.length();
if (!groups.containsKey(length)){
groups.put(length,new ArrayList<>());
}
groups.get(Length) .add(s);
}
    System.out.println(groups);

2.Lambda+stream分组
Map<Integer,List<String>> groups2 = list.stream().collect(Collectors.groupingBy(String::length));
System.out.println（groups2）

1.普通方式创建线程

Thread thread = newThread(new Runnable(){
@Override
public void run(){
System.out.println("hello world");
}
});
thread.start();

2.Lambda表达式

Thread thread1 = new Threal(() -> System.out.println(hello world"));
thread1.start();

1.创建接口
interface  MyInterface{
public void doSomething(String s);}

2.普通实现接口
MyInterface myInterface = new MyInterface{
    @override
    public void doSomething(String s){
    System.out.println(s);
    }
};
myInterface.doSomething( s:"hello world");

3.Lambda表达式实现接口
MyInterface myInterface1 = (s) -> System.out.println(s);
myInterface1.doSomething( s:"hello worLd")

String str = "hello world";

1.普通方式
if（str !=null）{
System.out.println(str.toUpperCase());}

2.Lambda表达式
Optional.ofNuLlable(str).map(String::toUpperCase).ifPresent(System.out::println);

List<String> List = Arrays.asList("apple","banana", "orange");
1.普通方式
List<String> list2 = new ArrayList<>();
for （String s:list2){ //遍历循环
    if （s.startsWith("a")){ //取出 包含a的元素
        list2.add(s.toUpperCase());//添加到list2中然后转换为大写
    }
}       Collections.sort(list2); //排序

2.Lambda+stream方式

List<String> list3 = list.stream().filter(s -> s.startsWith("a"))
.map(String::toupperCase).sorted().collect(collectors.toList());

public class Dept {
    private int id;

    public Dept(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Dept{id=" + id + "}";
    }
}

public class TestCollectStopOptions {

    public void testCollectStopOptions() {
        // 创建一个包含 Dept 对象的列表
        List<Dept> ids = Arrays.asList(new Dept(17), new Dept(22), new Dept(23));

        // 使用 Stream API 过滤 id 大于 20 的 Dept 对象，并收集到 List 中
        List<Dept> collectList = ids.stream()
                                   .filter(dept -> dept.getId() > 20)
                                   .collect(Collectors.toList());
        System.out.println("collectList: " + collectList);

        // 使用 Stream API 过滤 id 大于 20 的 Dept 对象，并收集到 Set 中
        Set<Dept> collectSet = ids.stream()
                                 .filter(dept -> dept.getId() > 20)
                                 .collect(Collectors.toSet());
        System.out.println("collectSet: " + collectSet);

        // 使用 Stream API 过滤 id 大于 20 的 Dept 对象，并收集到 Map 中，key 为 id，value 为 Dept 对象
        Map<Integer, Dept> collectMap = ids.stream()
                                          .filter(dept -> dept.getId() > 20)
                                          .collect(Collectors.toMap(Dept::getId, dept -> dept));
        System.out.println("collectMap: " + collectMap);
    }

    public static void main(String[] args) {
        new TestCollectStopOptions().testCollectStopOptions();
    }
}

结果

collectList:[Dept{id=22}, Dept{id=23}]
collectSet:[Dept{id=23}, Dept{id=22}]
collectMap:{22=Dept{id=22}, 23=Dept{id=23}}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class User {
    private String id;

    public User() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{id='" + id + '\'' + '}';
    }
}

public class TestStringToIntMap {

    /**
     * 演示map的用途：一对一转换
     */
    public void stringToIntMap() {
        // 创建一个包含字符串 ID 的列表
        List<String> ids = Arrays.asList("205", "105", "308", "469", "627", "193", "111");

        // 使用流操作
        List<User> results = ids.stream()
                               .map(id -> {
                                   // 创建一个新的 User 对象
                                   User user = new User();
                                   // 设置 User 对象的 id 属性
                                   user.setId(id);
                                   // 返回 User 对象
                                   return user;
                               })
                               .collect(Collectors.toList()); // 收集结果到一个新的 List 中

        // 打印结果
        System.out.println(results);
    }

    public static void main(String[] args) {
        new TestStringToIntMap().stringToIntMap();
    }
}

@注释笔记

@RequestBody ：获取请全体json字符串数据封装给java对象，封装的前提是 json字符串属性要与实体类属性名一致才可以封装。

—————————————————————————————–

#{name} 占位符会从方法参数对象里面调用getname封装方法获取数据映射到占位符位置。

#{参数名} 是Mybatis的参数占位符，可以自动将参数映射到SQL语句去执行

参数名要与接口方法的参数名要一致，但是方法只有一个参数时，参数名可以是任意的。

—————————————————————————————–

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的请求默认都会是 HTTP GET 类型的。比如@GetMapping

加入路径处理前端响应

—————————————————————————————–

注解@RequiredArgsConstructor 是 Lombok 提供的一个注解，其主要作用在于简化 @Autowired 的书写过程。在编写 Controller 层或 Service 层代码时，常常需要注入众多的 mapper 接口或 service 接口。若每个接口都使用 @Autowired 进行标注，代码会显得繁琐。而 @RequiredArgsConstructor 注解能够替代 @Autowired 注解，但需注意，在类上添加 @RequiredArgsConstructor 时，需要注入的类必须使用 final 进行声明。

—————————————————————————————–

@Repository ：@Repository的作用与@Controller，@Service的作用都是把对象交给Spring管理。@Repository是标注在Dao层接口上，作用是将接口的一个实现类交给Spring管理。

—————————————————————————————–

@Mapper

@Mapper: 这个注解一般使用在Dao层接口上，相当于一个mapper.xml文件，它的作用就是将接口生成一个动态代理类。加入了@Mapper注解，目的就是为了不再写mapper映射文件。这个注解就是用来映射mapper.xml文件的。

使用@mapper后，不需要在spring配置中设置扫描地址，通过mapper.xml里面的namespace属性对应相关的mapper类，spring将动态的生成Bean后注入到ServiceImpl中

注意：

在Dao层不要存在相同名字的接口，也就是在Dao不要写重载。因为mapper文件是通过id与接口进行对应的，如果写了两个同名的接口，就会导致mapper文件映射出错。

—————————————————————————————–

@Transactional

Spring事务管理-控制事务注解:@Transactional

作用:将当前方法交给spring进行事务管理，方法执行前，开启事务;成功执行完毕，提交事务;出现异常，回滚事务放在类上则是整个类都会启动事务放在接口上接口的实现类都会去启动事务。放在方法上此方法中的代码会启动事务。

—————————————————————————————–

规则:JSON数据的键名与方法形参对象的属性名相同，并需要使用@RequestBody注解标识。

—————————————————————————————–

MultipartFile 接收文件接口

—————————————————————————————–

@Service 表明这个是逻辑层可以被调用

—————————————————————————————–

@ConfigurationPropertise（）

—————————————————————————————–

@Autowired 注入bean

—————————————————————————————–

集合:@RequestParam[List ids

—————————————————————————————–

是一个在Java项目中常用的注解，特别是在使用日志框架如SLF4J时，通过在你的类上使用@Slf4j注解，Lombok会自动为你的类生成一个静态的日志字段，这个字段通常是org.slf4j.Logger类型的，并且通常命名为log。这样，你就可以在类中直接使用log.info(), log.error(), log.debug()等方法来记录日志，而无需手动声明和初始化Logger对象。

—————————————————————————————–

@PathVariable 是 Spring MVC 中用于将 URL 模板变量绑定到你控制器处理器方法参数上的注解。这个注解使得你可以从 URL 中提取出变量值，并将其作为参数传递给控制器的方法。

—————————————————————————————–

@RequestParam(defaultValue = “1”) 给参数设置默认值如果前端没有参数传进来默认值为1 可自己设置

—————————————————————————————–

@RequestBody 注解使用对象去接收的时候使用的注解

—————————————————————————————–

@RestControllerAdvice

—————————————————————————————–

@ExceptionHandler

—————————————————————————————–

限制请求的方式

@RequestMapping 可以放在类上，获取的路径可以当做所有方法的父路径

@PostMapping(value=”/depts”,method=RequestMethod.GET)注解可以放方法上，获取前端的路径。

@GetMapping（”/depts”）

@PutMapping

@DeleteMapping

—————————————————————————————–

junnit5

@Test

@ParameterizedTest

@BeforeEach

@AfterEach

@BeforeAll 标识静态方法

@AfterAll 标识静态方法

—————————————————————————————–

@RestController = @Controller+@ResponseBody

标识当前控制类所有方法都有了@ResponseBody

@ResponseBody 将控制器方法直接输出给前端，将java对象转换为json字符串输出给前端

—————————————————————————————–

lombok

—————————————————————————————–

在定义完Filter之后，Filter其实并不会生效，还需要完成Filter的配置，Filter的配置非常简单，只需要在Filter类上添加一个注解：@WebFilter，并指定属性urlPatterns，通过这个属性指定过滤器要拦截哪些请求。

当我们在Filter类上面加了@WebFilter注解之后，接下来我们还需要在启动类上面加上一个注解@ServletComponentScan，通过这个@ServletComponentScan注解来开启SpringBoot项目对于Servlet组件的支持。

@Order注解控制过滤器优先级数字越小优先级越高

—————————————————————————————–

Spring Boot 中注解的作用

Spring Boot 利用注解来简化配置和提高开发效率。主要注解包括但不限于：

@SpringBootApplication: 启动 Spring Boot 应用程序。

@Component, @Service, @Repository, @Controller: 标记组件，以便 Spring 容器可以自动检测和管理它们。

@Bean 该方法会在spring项目启动时自动调用，并将方法的返回值交给IOC容器管理 – bean对象

@Autowired: 用于自动装配 Bean。

@Bean: 在配置类中定义 Bean。

@Configuration: 定义配置类。

@EnableAutoConfiguration: 开启自动配置。

这些注解通常被组合使用，以提供一个高度可配置且易于扩展的应用程序结构。

12. @PathVariable, @RequestParam, @ModelAttribute, @RequestBody, @ResponseBody

参数绑定

这些注解用于从 HTTP 请求中提取参数，并将它们绑定到方法参数上。

@PathVariable: 用于从 URL 中提取路径变量。

@RequestParam: 用于从查询字符串中提取参数。

@ModelAttribute: 用于将多个请求参数绑定到一个对象上。

@RequestBody: 用于将请求体中的数据绑定到方法参数上。获取请求体json字符串数据封装给java对象

@ResponseBody: 用于将方法的结果直接写入响应体。

13. @RestController

控制器注解

@RestController 注解是一个组合注解，它等价于 @Controller 和 @ResponseBody 的组合。它表示这是一个 REST 控制器，所有返回值都将被序列化为 JSON 格式并直接写入 HTTP 响应体。

全局异常处理

@ControllerAdvice 注解用于定义全局异常处理类，它可以捕获控制器方法抛出的所有异常，并提供统一的错误响应。

@RunWith(SpringRunner.class)

测试运行器

@RunWith(SpringRunner.class) 注解告诉 JUnit 使用 Spring 测试运行器 (SpringRunner) 来运行测试。Spring 测试运行器提供了一种方便的方式来加载 Spring 上下文并管理测试生命周期。

整体测试

@SpringBootTest 注解用于执行整体测试，它会加载整个 Spring 应用上下文，包括所有自动配置的 Bean。这对于集成测试非常有用，因为它可以模拟完整的 Spring Boot 应用程序。

@Configuration 用于定义配置类，配置类中的bean可以自动装配到其他bean中

@Configuration类可以使用其他Spring注解，如@ComponentScan和@Import，来扫描组件或导入其他配置类

@Configuration类在Spring容器启动时会通过CGLIB动态代理机制生成代理类，以确保@Bean方法只被调用一次，从而保证单例bean的行为

环境和属性配置：
使用@PropertySource和@Value注解可以将外部属性文件中的值注入到配置类中

—————————————————————————————–

作用:按照一定的条件进行判断，在满足给定条件才会注册对应的bean对象到Spring IOC容器中。

位置:方法、类

@Conditional 本身是一个父注解，派生出大量子注解

@ConditionalonClass:判断环境中是否有对应节码文件才注册bean到IOC容器

对应的bean(类型或名称)，才注册bean到IOC容器@ConditionalOnMissingBean:判断环境中没@ConditionalonProperty:判断配置文件中有应属性和值，才注册bean到IOC容器。

—————————————————————————————–

SpringBoot 底层原理

bean获取。

@singleton 默认容器内同名称的bean只有一个实例（单例）

@prototype 每次使用该bean时会创建新的实例（非单例）

@request 每个请求范围内会创建新的实例（web环境中，了解即可）

@session 每个会话范围内都会创建新的实例（web环境中，了解）

@application 每个应用范围内会创建新的实例（web环境中，了解）

@Scope 设置bean的作用域

@Lazy 延迟加载会延迟到第一次使用的时候才会去加载

默认singleton的bean，在容器启动时被创建，可以使用aLazy注解来延迟初始化(延迟到第一次使用时)

prototype的bean，每一次使用该bean的时候都会创建一个新的实例。

实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性

– 非单例是每次使用时会创建一个全新的bean

@Import 是 Java 中 Spring 框架（特别是 Spring Framework 和 Spring Boot）中用于配置类的一个注解。它主要用于导入其他配置类，使得当前的配置类能够复用其他配置类中的配置信息，从而避免重复的配置代码。

@Conditional 是 Spring Framework 中的一个注解，它用于在自动配置类（@Configuration 类）中或者通过 @Bean 方法定义 bean 时，根据特定的条件来决定是否创建某个 bean 或配置。这个注解使得 Spring 的自动配置更加灵活和强大，因为它允许开发者基于特定的条件（如类路径上的特定类、操作系统属性、环境变量等）来启用或禁用配置。

—————————————————————————————–

@Transactional注解书写位置：

方法
- 当前方法交给spring进行事务管理
类
- 当前类中所有的方法都交由spring进行事务管理（推荐）
接口
- 接口下所有的实现类当中所有的方法都交给spring 进行事务管理

—————————————————————————————–

@Data是lombok注解,可以生成getter/setter方法,tostring/hashcode/equals等方法重写
```
@NoArgsConstructor /添加无参构造

@AllArgsConstructor //添加全参构造
```

—————————————————————————————–

@ResponseBody: 将控制器方法返回值直接输出给前端，将java对象转换为json字符串输出给前端@RestController = @controller + @ResponseBody

标识了当前控制器类所有方法就都有了@ResponseBody

@Controller : spring框架的ioc注解，用于给当前类创建实例对象，也就是加入ioc容器中。

@Autowired ：依赖注入注解:在运行时会从spring容器中找当前接口实现类对象并注入

@Qualifier(“Bean对象”)：指定Bean别名这与对象

@Qualifier常与@Autowired一起使用

@0ptions(useGeneratedKeys = true，keyProperty =”id”)//需要获取数据库赋值的id属性并赋值给对象的id

—————————————————————————————–

常用方法模板集合

@Test
1:JsONUtil.toJsonStr(paramMap)//将任意对象转换为json字符串形式
                     
//使用hutool工具类把BedDto类型转换成Bed实体类 类型
2:Bed bean = BeanUtil.toBean(bedDto, Bed.class);

//判断对象是否为null 如果为null 返回true
3:Objects.isNull(xx)

//判断对象是否不为null 如果不为null 返回true
4:Objects.nonNull(xx)
                  
//工具类Objects 专门用来解决空指针异常 意思 先判断s1！=null 在调用s1.equals(s2)
5:Objects.equals(s1,s2)

//强转方法
6:String.valueOf() 

//整个对象的转换方法
7:BeanUtils.copyProperties(user,userPojo) 

8:StringUtils.toStringArray(把括号中的内容转换为一个字符串类型数组)

//在java中，JSONOBject类中的get（String key）方法接收一个字符串参数作为键名，用于从JSON对象中获取对应的值，这种方法运行通过建模来检索特定的数据项
//当我们调用JSONOBject.get("acces_token")的时候，实际上是在告诉程序：请查找名为“access_token”的键，并返回其关键的值，
//如果找到匹配的键，则返回相应的值，如果没有找到，则返回null
9:JSONOBject.get("acces_token")
//建造者设计模式：利用各种组件（各种属性）随意组合生成对象，目的是创建对象更加灵活
//与直接调用构造函数对比
//类一般要提供很多构造函数才可以灵活构建对象，这种方式很麻烦
//建造者模式创建对象底层只需需要提供一个构造函数即可，在使用的时候想设置哪个属性就设置哪个属性，最终都调用同一个构造函数
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder给当前类添加建造者设计模式创建对象    这几个注解都要有
10：member = Member.builder()
.openId(openid)
.build();

LOADING...

Stream模板+Lambda常用+@注释+常用方法模板集合

Stream模板

中间方法

Stream中间代码

stream流超强引用

Lambda+Stream实用方法

@注释笔记

常用方法模板集合